import api from './api';

/**
 * 获取所有联系人
 */
export const getContacts = async () => {
  try {
    const response = await api.get('/whatsapp/contacts');
    return response.data;
  } catch (error) {
    console.error('获取联系人失败:', error);
    throw error;
  }
};

/**
 * 获取单个联系人详情
 */
export const getContact = async (contactId) => {
  try {
    const response = await api.get(`/whatsapp/contacts/${contactId}`);
    return response.data;
  } catch (error) {
    console.error('获取联系人详情失败:', error);
    throw error;
  }
};

/**
 * 获取所有聊天
 */
export const getChats = async () => {
  try {
    const response = await api.get('/whatsapp/chats');
    return response.data;
  } catch (error) {
    console.error('获取聊天列表失败:', error);
    throw error;
  }
};

/**
 * 获取聊天历史记录
 * @param {string} contactId 联系人ID
 * @param {number} limit 消息数量限制，默认50条
 * @param {string} beforeId 加载该消息ID之前的消息，用于分页加载
 */
export const getChatHistory = async (contactId, limit = 50, beforeId = null) => {
  try {
    // 验证contactId
    if (!contactId) {
      console.warn('获取聊天历史: 没有提供联系人ID');
      return [];
    }
    
    // 确保limit是有效数字
    const validLimit = Number.isInteger(limit) && limit > 0 ? limit : 50;
    
    // 构建查询参数
    const params = { limit: validLimit };
    if (beforeId) {
      params.beforeId = beforeId;
    }
    
    console.log(`正在获取联系人 ${contactId} 的聊天历史, 限制: ${validLimit}, beforeId: ${beforeId || 'none'}`);
    
    const response = await api.get(`/messages/${contactId}`, { 
      params,
      // 增加超时时间，因为获取消息可能需要较长时间
      timeout: 20000
    });
    
    // 检查返回数据的有效性
    if (!response.data || !Array.isArray(response.data)) {
      console.warn('获取聊天历史: 服务器返回无效数据', response.data);
      return [];
    }
    
    console.log(`成功获取 ${response.data.length} 条聊天历史`);
    return response.data;
  } catch (error) {
    console.error('获取聊天历史失败:', error);
    console.error('错误详情:', error.response?.status, error.response?.data);
    
    // API错误时详细记录
    if (error.response) {
      const { status, data } = error.response;
      if (status === 404) {
        console.warn('获取聊天历史: 未找到指定聊天', contactId);
      } else {
        console.error(`获取聊天历史: HTTP错误 ${status}`, data);
      }
    }
    
    // 失败时返回空数组，而不是抛出错误
    return [];
  }
};

/**
 * 发送文本消息
 * @param {string} contactId 联系人ID
 * @param {string} content 消息内容
 * @returns {Promise<Object>} 发送结果
 */
export const sendMessage = async (contactId, content) => {
  // 参数验证
  if (!contactId) {
    console.error('发送消息错误: 未提供联系人ID');
    throw new Error('联系人ID不能为空');
  }
  
  if (!content || typeof content !== 'string' || !content.trim()) {
    console.error('发送消息错误: 消息内容为空');
    throw new Error('消息内容不能为空');
  }
  
  // 发送消息的最大尝试次数
  const maxRetries = 2;
  let retryCount = 0;
  let lastError = null;
  
  while (retryCount <= maxRetries) {
    try {
      console.log(`尝试发送消息到 ${contactId}，尝试 ${retryCount + 1}/${maxRetries + 1}`);
      
      const response = await api.post('/messages/send', {
        contactId,
        content
      }, {
        timeout: 15000 // 15秒超时
      });
      
      console.log('消息发送成功:', response.data);
      
      // 处理返回结果
      if (response.data && response.data.success) {
        // 标准化成功返回
        return {
          success: true,
          messageId: response.data.messageId || response.data.id || `local_${Date.now()}`,
          timestamp: response.data.timestamp || new Date().toISOString(),
          status: response.data.status || 'sent'
        };
      } else if (response.data) {
        // 服务器返回了响应，但不是预期的成功格式
        return {
          success: true, // 前端视为成功
          messageId: `local_${Date.now()}`,
          timestamp: new Date().toISOString(),
          status: 'sent',
          warning: '服务器返回了非标准响应',
          originalResponse: response.data
        };
      } else {
        // 没有响应数据但HTTP状态码是成功的
        return {
          success: true,
          messageId: `local_${Date.now()}`,
          timestamp: new Date().toISOString(),
          status: 'sent'
        };
      }
    } catch (error) {
      lastError = error;
      retryCount++;
      
      // 打印详细错误信息
      console.error(`发送消息失败 (尝试 ${retryCount}/${maxRetries + 1}):`, error);
      if (error.response) {
        console.error('错误响应:', error.response.status, error.response.data);
      }
      
      if (retryCount <= maxRetries) {
        // 计算退避时间
        const backoffTime = 1000 * retryCount; // 1秒, 2秒...
        console.log(`等待 ${backoffTime}ms 后重试...`);
        await new Promise(resolve => setTimeout(resolve, backoffTime));
      } else {
        // 所有重试都失败了
        console.error(`所有 ${maxRetries + 1} 次尝试发送消息都失败了`);
        
        // 返回一个包含错误信息的对象，但允许前端继续显示消息
        return {
          success: false,
          localOnly: true,
          messageId: `local_failed_${Date.now()}`,
          timestamp: new Date().toISOString(),
          status: 'failed',
          error: lastError.message,
          errorCode: lastError.response?.status || 'NETWORK_ERROR'
        };
      }
    }
  }
  
  // 不应该到达这里，但为了安全起见
  throw lastError || new Error('发送消息失败');
};

/**
 * 发送图片
 */
export const sendImage = async (contactId, imageFile, caption = '') => {
  try {
    const formData = new FormData();
    formData.append('contactId', contactId);
    formData.append('image', imageFile);
    
    if (caption) {
      formData.append('caption', caption);
    }
    
    const response = await api.post('/messages/send-image', formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    });
    
    return response.data;
  } catch (error) {
    console.error('发送图片失败:', error);
    throw error;
  }
};

/**
 * 发送文件
 */
export const sendFile = async (contactId, file, caption = '') => {
  try {
    const formData = new FormData();
    formData.append('contactId', contactId);
    formData.append('file', file);
    
    if (caption) {
      formData.append('caption', caption);
    }
    
    const response = await api.post('/messages/send-file', formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    });
    
    return response.data;
  } catch (error) {
    console.error('发送文件失败:', error);
    throw error;
  }
};

/**
 * 发送预设文件
 */
export const sendPresetFile = async (contactId, presetId) => {
  try {
    const response = await api.post('/messages/send-preset', {
      contactId,
      presetId
    });
    return response.data;
  } catch (error) {
    console.error('发送预设文件失败:', error);
    throw error;
  }
};

/**
 * 标记聊天为已读
 * @param {string} contactId 联系人ID
 * @returns {Promise<Object>} 操作结果
 */
export const markChatAsRead = async (contactId) => {
  // 如果没有联系人ID，直接返回成功
  if (!contactId) {
    console.log('标记聊天为已读：跳过 - 没有提供联系人ID');
    return { success: true, message: '操作跳过' };
  }
  
  try {
    // 确保联系人ID是可用的格式
    let formattedId = contactId;
    
    // 检查是否为有效ID格式
    if (typeof contactId !== 'string' && typeof contactId !== 'number') {
      // 如果是对象类型，尝试提取ID
      if (contactId && typeof contactId === 'object') {
        if (contactId.id) {
          formattedId = contactId.id;
        } else if (contactId._serialized) {
          formattedId = contactId._serialized;
        } else if (contactId.user) {
          formattedId = contactId.user;
        } else {
          // 尝试将整个对象序列化为JSON
          try {
            formattedId = JSON.stringify(contactId);
          } catch (e) {
            console.log('标记聊天为已读：跳过 - 联系人ID序列化失败');
            return { success: true, message: '操作跳过' };
          }
        }
      } else {
        console.log('标记聊天为已读：跳过 - 无效的联系人ID类型', typeof contactId);
        return { success: true, message: '操作跳过' };
      }
    }
    
    // 将ID转换为字符串
    formattedId = String(formattedId).trim();
    
    if (!formattedId) {
      console.log('标记聊天为已读：跳过 - 处理后ID为空');
      return { success: true, message: '操作跳过' };
    }
    
    console.log(`尝试标记聊天为已读，ID: ${formattedId}`);
    
    // 记录请求开始时间，用于计算延迟
    const startTime = Date.now();
    
    // 发送请求
    const response = await api.post(`/messages/chats/${formattedId}/read`, null, {
      // 增加超时时间
      timeout: 15000,
      // 不要自动抛出错误
      validateStatus: status => true
    });
    
    // 计算请求延迟
    const delay = Date.now() - startTime;
    console.log(`标记聊天为已读请求完成，状态码: ${response.status}，耗时: ${delay}ms`);
    
    // 检查响应状态码
    if (response.status >= 200 && response.status < 300) {
      // 服务器返回成功状态码
      if (response.data && typeof response.data === 'object') {
        // 响应是对象类型，直接返回（可能包含success=false）
        console.log(`标记聊天为已读结果:`, response.data);
        return {
          ...response.data,
          // 确保有success字段
          success: response.data.success !== undefined ? response.data.success : true,
          // 确保有message字段
          message: response.data.message || '聊天标记为已读'
        };
      } else {
        // 没有响应数据或非对象
        return { success: true, message: '聊天标记为已读' };
      }
    } else {
      // 服务器返回错误状态码，但我们仍然尝试解析响应
      console.warn(`标记聊天为已读失败: HTTP ${response.status}`);
      return { 
        success: false, 
        silentError: true, 
        message: '标记为已读失败，但不影响使用',
        statusCode: response.status
      };
    }
  } catch (error) {
    // 记录详细错误信息
    console.error('标记聊天为已读失败:', error);
    if (error.response) {
      console.error('错误响应:', error.response.status, error.response.data);
    }
    
    // 返回带有详细信息的错误对象，但不会显示给用户的错误
    return { 
      success: false, 
      silentError: true, 
      message: '标记为已读失败，但不影响使用'
    };
  }
};

/**
 * 搜索消息
 */
export const searchMessages = async (query, contactId = null) => {
  try {
    const params = { query };
    if (contactId) {
      params.contactId = contactId;
    }
    
    const response = await api.get('/messages/search', { params });
    return response.data;
  } catch (error) {
    console.error('搜索消息失败:', error);
    throw error;
  }
};

/**
 * 获取WhatsApp连接状态
 */
export const getWhatsAppStatus = async () => {
  try {
    const response = await api.get('/whatsapp/status');
    return response.data;
  } catch (error) {
    console.error('获取WhatsApp状态失败:', error);
    throw error;
  }
};

/**
 * 初始化WhatsApp连接
 */
export const initializeWhatsApp = async () => {
  try {
    const response = await api.post('/whatsapp/initialize');
    return response.data;
  } catch (error) {
    console.error('初始化WhatsApp连接失败:', error);
    throw error;
  }
};

/**
 * 获取二维码
 */
export const getQRCode = async () => {
  try {
    const response = await api.get('/whatsapp/qrcode');
    return response.data;
  } catch (error) {
    console.error('获取二维码失败:', error);
    // 404错误表示二维码尚未生成，不是真正的错误
    if (error.response && error.response.status === 404) {
      return { qrCode: null, message: error.response.data.message };
    }
    throw error;
  }
};

export default {
  getContacts,
  getContact,
  getChats,
  getChatHistory,
  sendMessage,
  sendImage,
  sendFile,
  sendPresetFile,
  markChatAsRead,
  searchMessages,
  getWhatsAppStatus,
  initializeWhatsApp,
  getQRCode
}; 